/**
  @file     	Computer.h 
  @brief    	all kinds of Computer
  @author  	arvin
  @version 	1.0   2012/12/20
 */

#ifndef CXX_COMPUTER_H
#define CXX_COMPUTER_H
#include "ProductDef.h"
#include <vector>
#include "Mouse.h"

class Mouse;
class Keyboard;
class Monitor;
class Host;

enum enum_letter
{
	enum_letter_none = 0,

	enum_letter_all,
	enum_letter_invalid = -1,
};

enum ENUM_UPPER
{
	ENUM_UPPER_NONE = 0,

	ENUM_UPPER_ALL,
	ENUM_UPPER_INVALID = -1,
};

class AbstractComputer
{
public:

	/**
	* Destruction
	*
	* @param VOID
	* @return 
	*/
    virtual ~AbstractComputer();

	/**
	* Operation
	*
	* @param VOID
	* @return 
	*/
	virtual VOID Operation();

	/**
	* GetComputer
	*
	* @param VOID
	* @return COMPUTER_TYPE
	*/
	COMPUTER_TYPE GetComputer();
protected:
	/**
	* Construction
	*
	* @param COMPUTER_TYPE eComputer
	* @return 
	*/
	AbstractComputer(COMPUTER_TYPE eComputer);

	/**
	* SetComputer
	*
	* @param COMPUTER_TYPE eComputer
	* @return
	*/
	VOID SetComputer(COMPUTER_TYPE eComputer);

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	AbstractComputer();

	/**
	* Copy Construction
	*
	* @param const AbstractComputer& cAbstractComputer
	* @return 
	*/
	AbstractComputer(const AbstractComputer& cAbstractComputer);

	/**
	* Assignment
	*
	* @param const AbstractComputer& cAbstractComputer
	* @return AbstractComputer&
	*/
	AbstractComputer& operator=(const AbstractComputer& cAbstractComputer);

public:
protected:
private:
	COMPUTER_TYPE m_eComputer;
};

class NotebookComputer : public AbstractComputer
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~NotebookComputer();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

	/**
	* GetComputerPart
	*
	* @param VOID
	* @return COMPUTERPART_TYPE
	*/
	COMPUTERPART_TYPE GetComputerPart();


	/**
	* GetMouse
	*
	* @param const vector<Mouse*>&
	* @return
	*/
	const vector<Mouse*>& GetMouse();

	/**
	* GetKeyboard
	*
	* @param const vector<Keyboard*>&
	* @return
	*/
	const vector<Keyboard*>& GetKeyboard();

	/**
	* GetMonitor
	*
	* @param const vector<Monitor*>&
	* @return
	*/
	const vector<Monitor*>& GetMonitor();

	/**
	* GetHost
	*
	* @param const vector<Host*>&
	* @return
	*/
	const vector<Host*>& GetHost();
protected:
	/**
	* Construction
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @return
	*/
	NotebookComputer(COMPUTERPART_TYPE eComputerPart);

	/**
	* Construction
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @param const vector<Mouse*>& vMouse
	* @param const vector<Keyboard*>& vKeyboard
	* @param const vector<Monitor*>& vMonitor
	* @param const vector<Host*>& vHost
	* @return
	*/
	NotebookComputer(COMPUTERPART_TYPE eComputerPart, const vector<Mouse*>& vMouse, const vector<Keyboard*>& vKeyboard, const vector<Monitor*>& vMonitor, const vector<Host*>& vHost);

	/**
	* SetComputerPart
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @return
	*/
	VOID SetComputerPart(COMPUTERPART_TYPE eComputerPart);


	/**
	* SetMouse
	*
	* @param const vector<Mouse*>& vMouse
	* @return
	*/
	VOID SetMouse(const vector<Mouse*>& vMouse);

	/**
	* SetKeyboard
	*
	* @param const vector<Keyboard*>& vKeyboard
	* @return
	*/
	VOID SetKeyboard(const vector<Keyboard*>& vKeyboard);

	/**
	* SetMonitor
	*
	* @param const vector<Monitor*>& vMonitor
	* @return
	*/
	VOID SetMonitor(const vector<Monitor*>& vMonitor);

	/**
	* SetHost
	*
	* @param const vector<Host*>& vHost
	* @return
	*/
	VOID SetHost(const vector<Host*>& vHost);
private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	NotebookComputer();

	/**
	* Copy Construction
	*
	* @param const NotebookComputer& cNoteBookComputer
	* @return
	*/
	NotebookComputer(const NotebookComputer& cNoteBookComputer);

	/**
	* Assignment
	*
	* @param const NotebookComputer& cNoteBookComputer
	* @return NotebookComputer&
	*/
	NotebookComputer& operator=(const NotebookComputer& cNoteBookComputer);

public:
protected:
private:
	COMPUTERPART_TYPE m_eComputerPart;
	vector<Mouse*>			m_vMouse;
	vector<Keyboard*>		m_vKeyboard;
	vector<Monitor*>		m_vMonitor;
	vector<Host*>			m_vHost;
};

class DesktopComputer : public AbstractComputer
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~DesktopComputer();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

	/**
	* GetComputerPart
	*
	* @param VOID
	* @return COMPUTERPART_TYPE
	*/
	COMPUTERPART_TYPE GetComputerPart();

	/**
	* GetMouse
	*
	* @param const vector<Mouse*>&
	* @return
	*/
	const vector<Mouse*>& GetMouse();

	/**
	* GetKeyboard
	*
	* @param const vector<Keyboard*>&
	* @return
	*/
	const vector<Keyboard*>& GetKeyboard();

	/**
	* GetMonitor
	*
	* @param const vector<Monitor*>&
	* @return
	*/
	const vector<Monitor*>& GetMonitor();

	/**
	* GetHost
	*
	* @param const vector<Host*>&
	* @return
	*/
	const vector<Host*>& GetHost();
protected:
	/**
	* Construction
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @return
	*/
	DesktopComputer(COMPUTERPART_TYPE eComputerPart);

	/**
	* Construction
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @param const vector<Mouse*>& vMouse
	* @param const vector<Keyboard*>& vKeyboard
	* @param const vector<Monitor*>& vMonitor
	* @param const vector<Host*>& vHost
	* @return
	*/
	DesktopComputer(COMPUTERPART_TYPE eComputerPart, const vector<Mouse*>& vMouse, const vector<Keyboard*>& vKeyboard, const vector<Monitor*>& vMonitor, const vector<Host*>& vHost);

	/**
	* SetComputerPart
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @return
	*/
	VOID SetComputerPart(COMPUTERPART_TYPE eComputerPart);

	/**
	* SetMouse
	*
	* @param const vector<Mouse*>& vMouse
	* @return
	*/
	VOID SetMouse(const vector<Mouse*>& vMouse);

	/**
	* SetKeyboard
	*
	* @param const vector<Keyboard*>& vKeyboard
	* @return
	*/
	VOID SetKeyboard(const vector<Keyboard*>& vKeyboard);

	/**
	* SetMonitor
	*
	* @param const vector<Monitor*>& vMonitor
	* @return
	*/
	VOID SetMonitor(const vector<Monitor*>& vMonitor);

	/**
	* SetHost
	*
	* @param const vector<Host*>& vHost
	* @return
	*/
	VOID SetHost(const vector<Host*>& vHost);
private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	DesktopComputer();

	/**
	* Copy Construction
	*
	* @param const DesktopComputer& cDesktopComputer
	* @return
	*/
	DesktopComputer(const DesktopComputer& cDesktopComputer);

	/**
	* Assignment
	*
	* @param const DesktopComputer& cDesktopComputer
	* @return DesktopComputer&
	*/
	DesktopComputer& operator=(const DesktopComputer& cDesktopComputer);

public:
protected:
private:
	COMPUTERPART_TYPE m_eComputerPart;
	vector<Mouse*>			m_vMouse;
	vector<Keyboard*>		m_vKeyboard;
	vector<Monitor*>		m_vMonitor;
	vector<Host*>			m_vHost;
};

class ServerComputer : public AbstractComputer
{
public:
	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~ServerComputer();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

	/**
	* GetComputerPart
	*
	* @param VOID
	* @return COMPUTERPART_TYPE
	*/
	COMPUTERPART_TYPE GetComputerPart();


	/**
	* GetMouse
	*
	* @param const vector<Mouse*>&
	* @return
	*/
	const vector<Mouse*>& GetMouse();

	/**
	* GetKeyboard
	*
	* @param const vector<Keyboard*>&
	* @return
	*/
	const vector<Keyboard*>& GetKeyboard();

	/**
	* GetMonitor
	*
	* @param const vector<Monitor*>&
	* @return
	*/
	const vector<Monitor*>& GetMonitor();

	/**
	* GetHost
	*
	* @param const vector<Host*>&
	* @return
	*/
	const vector<Host*>& GetHost();
protected:
	/**
	* Construction
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @return
	*/
	ServerComputer(COMPUTERPART_TYPE eComputerPart);

	/**
	* Construction
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @param const vector<Mouse*>& vMouse
	* @param const vector<Keyboard*>& vKeyboard
	* @param const vector<Monitor*>& vMonitor
	* @param const vector<Host*>& vHost
	* @return
	*/
	ServerComputer(COMPUTERPART_TYPE eComputerPart, const vector<Mouse*>& vMouse, const vector<Keyboard*>& vKeyboard, const vector<Monitor*>& vMonitor, const vector<Host*>& vHost);

	/**
	* SetComputerPart
	*
	* @param COMPUTERPART_TYPE eComputerPart
	* @return
	*/
	VOID SetComputerPart(COMPUTERPART_TYPE eComputerPart);


	/**
	* SetMouse
	*
	* @param const vector<Mouse*>& vMouse
	* @return
	*/
	VOID SetMouse(const vector<Mouse*>& vMouse);

	/**
	* SetKeyboard
	*
	* @param const vector<Keyboard*>& vKeyboard
	* @return
	*/
	VOID SetKeyboard(const vector<Keyboard*>& vKeyboard);

	/**
	* SetMonitor
	*
	* @param const vector<Monitor*>& vMonitor
	* @return
	*/
	VOID SetMonitor(const vector<Monitor*>& vMonitor);

	/**
	* SetHost
	*
	* @param const vector<Host*>& vHost
	* @return
	*/
	VOID SetHost(const vector<Host*>& vHost);
private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	ServerComputer();

	/**
	* Copy Construction
	*
	* @param const ServerComputer& cServerComputer
	* @return
	*/
	ServerComputer(const ServerComputer& cServerComputer);

	/**
	* Assignment
	*
	* @param const ServerComputer& cServerComputer
	* @return ServerComputer&
	*/
	ServerComputer& operator=(const ServerComputer& cServerComputer);

public:
protected:
private:
	COMPUTERPART_TYPE m_eComputerPart;
	vector<Mouse*>			m_vMouse;
	vector<Keyboard*>		m_vKeyboard;
	vector<Monitor*>		m_vMonitor;
	vector<Host*>			m_vHost;
};


class NotebookComputerDoubleKeyboard : public NotebookComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard1
	* @param Keyboard* pKeyboard2
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	NotebookComputerDoubleKeyboard(Mouse* pMouse, Keyboard* pKeyboard1, Keyboard* pKeyboard2, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~NotebookComputerDoubleKeyboard();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:

	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	NotebookComputerDoubleKeyboard();

	/**
	* Copy Construction
	*
	* @param const NotebookComputerDoubleKeyboard& cNotebookComputerDoubleKeyboard
	* @return
	*/
	NotebookComputerDoubleKeyboard(const NotebookComputerDoubleKeyboard& cNotebookComputerDoubleKeyboard);

	/**
	* Assignment
	*
	* @param const NotebookComputerDoubleKeyboard& cNotebookComputerDoubleKeyboard
	* @return NotebookComputerDoubleKeyboard&
	*/
	NotebookComputerDoubleKeyboard& operator=(const NotebookComputerDoubleKeyboard& cNotebookComputerDoubleKeyboard);

public:
protected:
private:
};

class NotebookComputerDoubleMonitor : public NotebookComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor1
	* @param Monitor* pMonitor2
	* @param Host* pHost
	* @return
	*/
	NotebookComputerDoubleMonitor(Mouse* pMouse, Keyboard* pKeyboard, Monitor* pMonitor1, Monitor* pMonitor2, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~NotebookComputerDoubleMonitor();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	NotebookComputerDoubleMonitor();

	/**
	* Copy Construction
	*
	* @param const NotebookComputerDoubleMonitor& cNotebookComputerDoubleMonitor
	* @return
	*/
	NotebookComputerDoubleMonitor(const NotebookComputerDoubleMonitor& cNotebookComputerDoubleMonitor);

	/**
	* Assignment
	*
	* @param const NotebookComputerDoubleMonitor& cNotebookComputerDoubleMonitor
	* @return NotebookComputerDoubleMonitor&
	*/
	NotebookComputerDoubleMonitor& operator=(const NotebookComputerDoubleMonitor& cNotebookComputerDoubleMonitor);

public:
protected:
private:
};

class ServerComputerNormal : public ServerComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	ServerComputerNormal(Mouse* pMouse, Keyboard* pKeyboard, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~ServerComputerNormal();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	ServerComputerNormal();

	/**
	* Copy Construction
	*
	* @param const ServerComputerNormal& cServerComputerNormal
	* @return
	*/
	ServerComputerNormal(const ServerComputerNormal& cServerComputerNormal);

	/**
	* Assignment
	*
	* @param const ServerComputerNormal& cServerComputerNormal
	* @return ServerComputerNormal&
	*/
	ServerComputerNormal& operator=(const ServerComputerNormal& cServerComputerNormal);

public:
protected:
private:
};

class DesktopComputerNormal : public DesktopComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	DesktopComputerNormal(Mouse* pMouse, Keyboard* pKeyboard, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~DesktopComputerNormal();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	DesktopComputerNormal();

	/**
	* Copy Construction
	*
	* @param const DesktopComputerNormal& cDesktopComputerNormal
	* @return
	*/
	DesktopComputerNormal(const DesktopComputerNormal& cDesktopComputerNormal);

	/**
	* Assignment
	*
	* @param const DesktopComputerNormal& cDesktopComputerNormal
	* @return DesktopComputerNormal&
	*/
	DesktopComputerNormal& operator=(const DesktopComputerNormal& cDesktopComputerNormal);

public:
protected:
private:
};

class DesktopComputerDoubleMouse : public DesktopComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse1
	* @param Mouse* pMouse2
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	DesktopComputerDoubleMouse(Mouse* pMouse1, Mouse* pMouse2, Keyboard* pKeyboard, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~DesktopComputerDoubleMouse();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	DesktopComputerDoubleMouse();

	/**
	* Copy Construction
	*
	* @param const DesktopComputerDoubleMouse& cDesktopComputerDoubleMouse
	* @return
	*/
	DesktopComputerDoubleMouse(const DesktopComputerDoubleMouse& cDesktopComputerDoubleMouse);

	/**
	* Assignment
	*
	* @param const DesktopComputerDoubleMouse& cDesktopComputerDoubleMouse
	* @return DesktopComputerDoubleMouse&
	*/
	DesktopComputerDoubleMouse& operator=(const DesktopComputerDoubleMouse& cDesktopComputerDoubleMouse);

public:
protected:
private:
};

class DesktopComputerDoubleKeyboard : public DesktopComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard1
	* @param Keyboard* pKeyboard2
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	DesktopComputerDoubleKeyboard(Mouse* pMouse, Keyboard* pKeyboard1, Keyboard* pKeyboard2, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~DesktopComputerDoubleKeyboard();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:

	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	DesktopComputerDoubleKeyboard();

	/**
	* Copy Construction
	*
	* @param const DesktopComputerDoubleKeyboard& cDesktopComputerDoubleKeyboard
	* @return
	*/
	DesktopComputerDoubleKeyboard(const DesktopComputerDoubleKeyboard& cDesktopComputerDoubleKeyboard);

	/**
	* Assignment
	*
	* @param const DesktopComputerDoubleKeyboard& cDesktopComputerDoubleKeyboard
	* @return DesktopComputerDoubleKeyboard&
	*/
	DesktopComputerDoubleKeyboard& operator=(const DesktopComputerDoubleKeyboard& cDesktopComputerDoubleKeyboard);

public:
protected:
private:
};

class DesktopComputerDoubleMonitor : public DesktopComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor1
	* @param Monitor* pMonitor2
	* @param Host* pHost
	* @return
	*/
	DesktopComputerDoubleMonitor(Mouse* pMouse, Keyboard* pKeyboard, Monitor* pMonitor1, Monitor* pMonitor2, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~DesktopComputerDoubleMonitor();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	DesktopComputerDoubleMonitor(VOID);

	/**
	* Copy Construction
	*
	* @param const DesktopComputerDoubleMonitor& cDesktopComputerDoubleMonitor
	* @return
	*/
	DesktopComputerDoubleMonitor(const DesktopComputerDoubleMonitor& cDesktopComputerDoubleMonitor);

	/**
	* Assignment
	*
	* @param const DesktopComputerDoubleMonitor& cDesktopComputerDoubleMonitor
	* @return DesktopComputerDoubleMonitor&
	*/
	DesktopComputerDoubleMonitor& operator=(const DesktopComputerDoubleMonitor& cDesktopComputerDoubleMonitor);

public:
protected:
private:
};

class NotebookComputerNormal : public NotebookComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	NotebookComputerNormal(Mouse* pMouse, Keyboard* pKeyboard, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~NotebookComputerNormal();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	NotebookComputerNormal();

	/**
	* Copy Construction
	*
	* @param const NotebookComputerNormal& cNotebookComputerNormal
	* @return
	*/
	NotebookComputerNormal(const NotebookComputerNormal& cNotebookComputerNormal);

	/**
	* Assignment
	*
	* @param const NotebookComputerNormal& cNotebookComputerNormal
	* @return NotebookComputerNormal&
	*/
	NotebookComputerNormal& operator=(const NotebookComputerNormal& cNotebookComputerNormal);

public:
protected:
private:
};

class NotebookComputerDoubleMouse : public NotebookComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse1
	* @param Mouse* pMouse2
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	NotebookComputerDoubleMouse(Mouse* pMouse1, Mouse* pMouse2, Keyboard* pKeyboard, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~NotebookComputerDoubleMouse();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	NotebookComputerDoubleMouse();

	/**
	* Copy Construction
	*
	* @param const NotebookComputerDoubleMouse& cNotebookComputerDoubleMouse
	* @return
	*/
	NotebookComputerDoubleMouse(const NotebookComputerDoubleMouse& cNotebookComputerDoubleMouse);

	/**
	* Assignment
	*
	* @param const NotebookComputerDoubleMouse& cNotebookComputerDoubleMouse
	* @return NotebookComputerDoubleMouse&
	*/
	NotebookComputerDoubleMouse& operator=(const NotebookComputerDoubleMouse& cNotebookComputerDoubleMouse);

public:
protected:
private:
};

class ServerComputerDoubleMouse : public ServerComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse1
	* @param Mouse* pMouse2
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	ServerComputerDoubleMouse(Mouse* pMouse1, Mouse* pMouse2, Keyboard* pKeyboard, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~ServerComputerDoubleMouse();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	ServerComputerDoubleMouse();

	/**
	* Copy Construction
	*
	* @param const ServerComputerDoubleMouse& cServerComputerDoubleMouse
	* @return
	*/
	ServerComputerDoubleMouse(const ServerComputerDoubleMouse& cServerComputerDoubleMouse);

	/**
	* Assignment
	*
	* @param const ServerComputerDoubleMouse& cServerComputerDoubleMouse
	* @return ServerComputerDoubleMouse&
	*/
	ServerComputerDoubleMouse& operator=(const ServerComputerDoubleMouse& cServerComputerDoubleMouse);

public:
protected:
private:
};

class ServerComputerDoubleKeyboard : public ServerComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard1
	* @param Keyboard* pKeyboard2
	* @param Monitor* pMonitor
	* @param Host* pHost
	* @return
	*/
	ServerComputerDoubleKeyboard(Mouse* pMouse, Keyboard* pKeyboard1, Keyboard* pKeyboard2, Monitor* pMonitor, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~ServerComputerDoubleKeyboard();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:

	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	ServerComputerDoubleKeyboard();

	/**
	* Copy Construction
	*
	* @param const ServerComputerDoubleKeyboard& cServerComputerDoubleKeyboard
	* @return
	*/
	ServerComputerDoubleKeyboard(const ServerComputerDoubleKeyboard& cServerComputerDoubleKeyboard);

	/**
	* Assignment
	*
	* @param const ServerComputerDoubleKeyboard& cServerComputerDoubleKeyboard
	* @return ServerComputerDoubleKeyboard&
	*/
	ServerComputerDoubleKeyboard& operator=(const ServerComputerDoubleKeyboard& cServerComputerDoubleKeyboard);

public:
protected:
private:
};

class ServerComputerDoubleMonitor : public ServerComputer
{
public:
	/**
	* Construction
	*
	* @param Mouse* pMouse
	* @param Keyboard* pKeyboard
	* @param Monitor* pMonitor1
	* @param Monitor* pMonitor2
	* @param Host* pHost
	* @return
	*/
	ServerComputerDoubleMonitor(Mouse* pMouse, Keyboard* pKeyboard, Monitor* pMonitor1, Monitor* pMonitor2, Host* pHost);

	/**
	* Destruction
	*
	* @param VOID
	* @return
	*/
	virtual ~ServerComputerDoubleMonitor();

	/**
	* Operation
	*
	* @param VOID
	* @return
	*/
	virtual VOID Operation();

protected:

private:
	/**
	* Construction
	*
	* @param VOID
	* @return
	*/
	ServerComputerDoubleMonitor(VOID);

	/**
	* Copy Construction
	*
	* @param const ServerComputerDoubleMonitor& cServerComputerDoubleMonitor
	* @return
	*/
	ServerComputerDoubleMonitor(const ServerComputerDoubleMonitor& cServerComputerDoubleMonitor);

	/**
	* Assignment
	*
	* @param const ServerComputerDoubleMonitor& cServerComputerDoubleMonitor
	* @return ServerComputerDoubleMonitor&
	*/
	ServerComputerDoubleMonitor& operator=(const ServerComputerDoubleMonitor& cServerComputerDoubleMonitor);

public:
protected:
private:
};
#endif	/* >>CXX_COMPUTER_H<< */
/* EOF */